<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="datastore_v1beta2.html">Google Cloud Datastore API</a> . <a href="datastore_v1beta2.datasets.html">datasets</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#allocateIds">allocateIds(datasetId, body)</a></code></p>
<p class="firstline">Allocate IDs for incomplete keys (useful for referencing an entity before it is inserted).</p>
<p class="toc_element">
  <code><a href="#beginTransaction">beginTransaction(datasetId, body)</a></code></p>
<p class="firstline">Begin a new transaction.</p>
<p class="toc_element">
  <code><a href="#commit">commit(datasetId, body)</a></code></p>
<p class="firstline">Commit a transaction, optionally creating, deleting or modifying some entities.</p>
<p class="toc_element">
  <code><a href="#lookup">lookup(datasetId, body)</a></code></p>
<p class="firstline">Look up some entities by key.</p>
<p class="toc_element">
  <code><a href="#rollback">rollback(datasetId, body)</a></code></p>
<p class="firstline">Roll back a transaction.</p>
<p class="toc_element">
  <code><a href="#runQuery">runQuery(datasetId, body)</a></code></p>
<p class="firstline">Query for entities.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="allocateIds">allocateIds(datasetId, body)</code>
  <pre>Allocate IDs for incomplete keys (useful for referencing an entity before it is inserted).

Args:
  datasetId: string, Identifies the dataset. (required)
  body: object, The request body. (required)
    The object takes the form of:

{
    "keys": [ # A list of keys with incomplete key paths to allocate IDs for. No key may be reserved/read-only.
      { # A unique identifier for an entity.
        "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
          { # A (kind, ID/name) pair used to construct a key path.
              #
              # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
            "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
            "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
            "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
          },
        ],
        "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
            #
            # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
          "namespace": "A String", # The namespace.
          "datasetId": "A String", # The dataset ID.
        },
      },
    ],
  }


Returns:
  An object of the form:

    {
    "keys": [ # The keys specified in the request (in the same order), each with its key path completed with a newly allocated ID.
      { # A unique identifier for an entity.
        "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
          { # A (kind, ID/name) pair used to construct a key path.
              #
              # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
            "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
            "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
            "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
          },
        ],
        "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
            #
            # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
          "namespace": "A String", # The namespace.
          "datasetId": "A String", # The dataset ID.
        },
      },
    ],
    "header": {
      "kind": "datastore#responseHeader", # Identifies what kind of resource this is. Value: the fixed string "datastore#responseHeader".
    },
  }</pre>
</div>

<div class="method">
    <code class="details" id="beginTransaction">beginTransaction(datasetId, body)</code>
  <pre>Begin a new transaction.

Args:
  datasetId: string, Identifies the dataset. (required)
  body: object, The request body. (required)
    The object takes the form of:

{
    "isolationLevel": "A String", # The transaction isolation level. Either snapshot or serializable. The default isolation level is snapshot isolation, which means that another transaction may not concurrently modify the data that is modified by this transaction. Optionally, a transaction can request to be made serializable which means that another transaction cannot concurrently modify the data that is read or modified by this transaction.
  }


Returns:
  An object of the form:

    {
    "header": {
      "kind": "datastore#responseHeader", # Identifies what kind of resource this is. Value: the fixed string "datastore#responseHeader".
    },
    "transaction": "A String", # The transaction identifier (always present).
  }</pre>
</div>

<div class="method">
    <code class="details" id="commit">commit(datasetId, body)</code>
  <pre>Commit a transaction, optionally creating, deleting or modifying some entities.

Args:
  datasetId: string, Identifies the dataset. (required)
  body: object, The request body. (required)
    The object takes the form of:

{
    "ignoreReadOnly": True or False,
    "transaction": "A String", # The transaction identifier, returned by a call to beginTransaction. Must be set when mode is TRANSACTIONAL.
    "mode": "A String", # The type of commit to perform. Either TRANSACTIONAL or NON_TRANSACTIONAL.
    "mutation": { # A set of changes to apply. # The mutation to perform. Optional.
      "insert": [ # Entities to insert. Each inserted entity's key must have a complete path and must not be reserved/read-only.
        { # An entity.
          "properties": { # The entity's properties.
            "a_key": { # An entity property. # The name of the property. A property name matching regex "__.*__" is reserved. A reserved property name is forbidden in certain documented contexts. The name must not contain more than 500 characters. Cannot be "".
              "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
              "doubleValue": 3.14, # A double value.
              "integerValue": "A String", # An integer value.
              "meaning": 42, # The meaning field is reserved and should not be used.
              "dateTimeValue": "A String", # A timestamp value.
              "keyValue": { # A unique identifier for an entity. # A key value.
                "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                  { # A (kind, ID/name) pair used to construct a key path.
                      #
                      # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                    "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                    "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                    "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                  },
                ],
                "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                    #
                    # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                  "namespace": "A String", # The namespace.
                  "datasetId": "A String", # The dataset ID.
                },
              },
              "stringValue": "A String", # A UTF-8 encoded string value.
              "indexed": True or False, # If the value should be indexed.
                  #
                  # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
              "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
              "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                { # A message that can hold any of the supported value types and associated metadata.
                  "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
                  "doubleValue": 3.14, # A double value.
                  "integerValue": "A String", # An integer value.
                  "meaning": 42, # The meaning field is reserved and should not be used.
                  "dateTimeValue": "A String", # A timestamp value.
                  "keyValue": { # A unique identifier for an entity. # A key value.
                    "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                      { # A (kind, ID/name) pair used to construct a key path.
                          #
                          # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                        "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                        "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                        "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                      },
                    ],
                    "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                        #
                        # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                      "namespace": "A String", # The namespace.
                      "datasetId": "A String", # The dataset ID.
                    },
                  },
                  "stringValue": "A String", # A UTF-8 encoded string value.
                  "indexed": True or False, # If the value should be indexed.
                      #
                      # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
                  "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
                  "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                    # Object with schema name: Value
                  ],
                  "booleanValue": True or False, # A boolean value.
                  "blobKeyValue": "A String", # A blob key value.
                },
              ],
              "booleanValue": True or False, # A boolean value.
              "blobKeyValue": "A String", # A blob key value.
            },
          },
          "key": { # A unique identifier for an entity. # The entity's key.
              #
              # An entity must have a key, unless otherwise documented (for example, an entity in Value.entityValue may have no key). An entity's kind is its key's path's last element's kind, or null if it has no key.
            "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
              { # A (kind, ID/name) pair used to construct a key path.
                  #
                  # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
              },
            ],
            "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                #
                # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
              "namespace": "A String", # The namespace.
              "datasetId": "A String", # The dataset ID.
            },
          },
        },
      ],
      "force": True or False, # Ignore a user specified read-only period. Optional.
      "insertAutoId": [ # Insert entities with a newly allocated ID. Each inserted entity's key must omit the final identifier in its path and must not be reserved/read-only.
        { # An entity.
          "properties": { # The entity's properties.
            "a_key": { # An entity property. # The name of the property. A property name matching regex "__.*__" is reserved. A reserved property name is forbidden in certain documented contexts. The name must not contain more than 500 characters. Cannot be "".
              "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
              "doubleValue": 3.14, # A double value.
              "integerValue": "A String", # An integer value.
              "meaning": 42, # The meaning field is reserved and should not be used.
              "dateTimeValue": "A String", # A timestamp value.
              "keyValue": { # A unique identifier for an entity. # A key value.
                "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                  { # A (kind, ID/name) pair used to construct a key path.
                      #
                      # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                    "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                    "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                    "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                  },
                ],
                "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                    #
                    # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                  "namespace": "A String", # The namespace.
                  "datasetId": "A String", # The dataset ID.
                },
              },
              "stringValue": "A String", # A UTF-8 encoded string value.
              "indexed": True or False, # If the value should be indexed.
                  #
                  # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
              "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
              "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                { # A message that can hold any of the supported value types and associated metadata.
                  "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
                  "doubleValue": 3.14, # A double value.
                  "integerValue": "A String", # An integer value.
                  "meaning": 42, # The meaning field is reserved and should not be used.
                  "dateTimeValue": "A String", # A timestamp value.
                  "keyValue": { # A unique identifier for an entity. # A key value.
                    "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                      { # A (kind, ID/name) pair used to construct a key path.
                          #
                          # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                        "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                        "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                        "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                      },
                    ],
                    "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                        #
                        # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                      "namespace": "A String", # The namespace.
                      "datasetId": "A String", # The dataset ID.
                    },
                  },
                  "stringValue": "A String", # A UTF-8 encoded string value.
                  "indexed": True or False, # If the value should be indexed.
                      #
                      # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
                  "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
                  "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                    # Object with schema name: Value
                  ],
                  "booleanValue": True or False, # A boolean value.
                  "blobKeyValue": "A String", # A blob key value.
                },
              ],
              "booleanValue": True or False, # A boolean value.
              "blobKeyValue": "A String", # A blob key value.
            },
          },
          "key": { # A unique identifier for an entity. # The entity's key.
              #
              # An entity must have a key, unless otherwise documented (for example, an entity in Value.entityValue may have no key). An entity's kind is its key's path's last element's kind, or null if it has no key.
            "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
              { # A (kind, ID/name) pair used to construct a key path.
                  #
                  # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
              },
            ],
            "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                #
                # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
              "namespace": "A String", # The namespace.
              "datasetId": "A String", # The dataset ID.
            },
          },
        },
      ],
      "update": [ # Entities to update. Each updated entity's key must have a complete path and must not be reserved/read-only.
        { # An entity.
          "properties": { # The entity's properties.
            "a_key": { # An entity property. # The name of the property. A property name matching regex "__.*__" is reserved. A reserved property name is forbidden in certain documented contexts. The name must not contain more than 500 characters. Cannot be "".
              "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
              "doubleValue": 3.14, # A double value.
              "integerValue": "A String", # An integer value.
              "meaning": 42, # The meaning field is reserved and should not be used.
              "dateTimeValue": "A String", # A timestamp value.
              "keyValue": { # A unique identifier for an entity. # A key value.
                "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                  { # A (kind, ID/name) pair used to construct a key path.
                      #
                      # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                    "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                    "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                    "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                  },
                ],
                "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                    #
                    # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                  "namespace": "A String", # The namespace.
                  "datasetId": "A String", # The dataset ID.
                },
              },
              "stringValue": "A String", # A UTF-8 encoded string value.
              "indexed": True or False, # If the value should be indexed.
                  #
                  # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
              "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
              "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                { # A message that can hold any of the supported value types and associated metadata.
                  "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
                  "doubleValue": 3.14, # A double value.
                  "integerValue": "A String", # An integer value.
                  "meaning": 42, # The meaning field is reserved and should not be used.
                  "dateTimeValue": "A String", # A timestamp value.
                  "keyValue": { # A unique identifier for an entity. # A key value.
                    "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                      { # A (kind, ID/name) pair used to construct a key path.
                          #
                          # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                        "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                        "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                        "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                      },
                    ],
                    "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                        #
                        # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                      "namespace": "A String", # The namespace.
                      "datasetId": "A String", # The dataset ID.
                    },
                  },
                  "stringValue": "A String", # A UTF-8 encoded string value.
                  "indexed": True or False, # If the value should be indexed.
                      #
                      # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
                  "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
                  "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                    # Object with schema name: Value
                  ],
                  "booleanValue": True or False, # A boolean value.
                  "blobKeyValue": "A String", # A blob key value.
                },
              ],
              "booleanValue": True or False, # A boolean value.
              "blobKeyValue": "A String", # A blob key value.
            },
          },
          "key": { # A unique identifier for an entity. # The entity's key.
              #
              # An entity must have a key, unless otherwise documented (for example, an entity in Value.entityValue may have no key). An entity's kind is its key's path's last element's kind, or null if it has no key.
            "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
              { # A (kind, ID/name) pair used to construct a key path.
                  #
                  # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
              },
            ],
            "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                #
                # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
              "namespace": "A String", # The namespace.
              "datasetId": "A String", # The dataset ID.
            },
          },
        },
      ],
      "delete": [ # Keys of entities to delete. Each key must have a complete key path and must not be reserved/read-only.
        { # A unique identifier for an entity.
          "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
            { # A (kind, ID/name) pair used to construct a key path.
                #
                # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
              "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
              "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
              "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
            },
          ],
          "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
              #
              # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
            "namespace": "A String", # The namespace.
            "datasetId": "A String", # The dataset ID.
          },
        },
      ],
      "upsert": [ # Entities to upsert. Each upserted entity's key must have a complete path and must not be reserved/read-only.
        { # An entity.
          "properties": { # The entity's properties.
            "a_key": { # An entity property. # The name of the property. A property name matching regex "__.*__" is reserved. A reserved property name is forbidden in certain documented contexts. The name must not contain more than 500 characters. Cannot be "".
              "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
              "doubleValue": 3.14, # A double value.
              "integerValue": "A String", # An integer value.
              "meaning": 42, # The meaning field is reserved and should not be used.
              "dateTimeValue": "A String", # A timestamp value.
              "keyValue": { # A unique identifier for an entity. # A key value.
                "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                  { # A (kind, ID/name) pair used to construct a key path.
                      #
                      # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                    "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                    "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                    "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                  },
                ],
                "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                    #
                    # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                  "namespace": "A String", # The namespace.
                  "datasetId": "A String", # The dataset ID.
                },
              },
              "stringValue": "A String", # A UTF-8 encoded string value.
              "indexed": True or False, # If the value should be indexed.
                  #
                  # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
              "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
              "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                { # A message that can hold any of the supported value types and associated metadata.
                  "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
                  "doubleValue": 3.14, # A double value.
                  "integerValue": "A String", # An integer value.
                  "meaning": 42, # The meaning field is reserved and should not be used.
                  "dateTimeValue": "A String", # A timestamp value.
                  "keyValue": { # A unique identifier for an entity. # A key value.
                    "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                      { # A (kind, ID/name) pair used to construct a key path.
                          #
                          # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                        "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                        "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                        "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                      },
                    ],
                    "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                        #
                        # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                      "namespace": "A String", # The namespace.
                      "datasetId": "A String", # The dataset ID.
                    },
                  },
                  "stringValue": "A String", # A UTF-8 encoded string value.
                  "indexed": True or False, # If the value should be indexed.
                      #
                      # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
                  "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
                  "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                    # Object with schema name: Value
                  ],
                  "booleanValue": True or False, # A boolean value.
                  "blobKeyValue": "A String", # A blob key value.
                },
              ],
              "booleanValue": True or False, # A boolean value.
              "blobKeyValue": "A String", # A blob key value.
            },
          },
          "key": { # A unique identifier for an entity. # The entity's key.
              #
              # An entity must have a key, unless otherwise documented (for example, an entity in Value.entityValue may have no key). An entity's kind is its key's path's last element's kind, or null if it has no key.
            "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
              { # A (kind, ID/name) pair used to construct a key path.
                  #
                  # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
              },
            ],
            "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                #
                # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
              "namespace": "A String", # The namespace.
              "datasetId": "A String", # The dataset ID.
            },
          },
        },
      ],
    },
  }


Returns:
  An object of the form:

    {
    "header": {
      "kind": "datastore#responseHeader", # Identifies what kind of resource this is. Value: the fixed string "datastore#responseHeader".
    },
    "mutationResult": { # The result of performing the mutation (if any).
      "insertAutoIdKeys": [ # Keys for insertAutoId entities. One per entity from the request, in the same order.
        { # A unique identifier for an entity.
          "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
            { # A (kind, ID/name) pair used to construct a key path.
                #
                # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
              "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
              "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
              "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
            },
          ],
          "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
              #
              # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
            "namespace": "A String", # The namespace.
            "datasetId": "A String", # The dataset ID.
          },
        },
      ],
      "indexUpdates": 42, # Number of index writes.
    },
  }</pre>
</div>

<div class="method">
    <code class="details" id="lookup">lookup(datasetId, body)</code>
  <pre>Look up some entities by key.

Args:
  datasetId: string, Identifies the dataset. (required)
  body: object, The request body. (required)
    The object takes the form of:

{
    "keys": [ # Keys of entities to look up from the datastore.
      { # A unique identifier for an entity.
        "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
          { # A (kind, ID/name) pair used to construct a key path.
              #
              # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
            "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
            "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
            "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
          },
        ],
        "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
            #
            # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
          "namespace": "A String", # The namespace.
          "datasetId": "A String", # The dataset ID.
        },
      },
    ],
    "readOptions": { # Options for this lookup request. Optional.
      "transaction": "A String", # The transaction to use. Optional.
      "readConsistency": "A String", # The read consistency to use. One of default, strong, or eventual. Cannot be set when transaction is set. Lookup and ancestor queries default to strong, global queries default to eventual and cannot be set to strong. Optional. Default is default.
    },
  }


Returns:
  An object of the form:

    {
    "deferred": [ # A list of keys that were not looked up due to resource constraints.
      { # A unique identifier for an entity.
        "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
          { # A (kind, ID/name) pair used to construct a key path.
              #
              # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
            "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
            "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
            "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
          },
        ],
        "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
            #
            # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
          "namespace": "A String", # The namespace.
          "datasetId": "A String", # The dataset ID.
        },
      },
    ],
    "missing": [ # Entities not found, with only the key populated.
      { # The result of fetching an entity from the datastore.
        "entity": { # An entity. # The resulting entity.
          "properties": { # The entity's properties.
            "a_key": { # An entity property. # The name of the property. A property name matching regex "__.*__" is reserved. A reserved property name is forbidden in certain documented contexts. The name must not contain more than 500 characters. Cannot be "".
              "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
              "doubleValue": 3.14, # A double value.
              "integerValue": "A String", # An integer value.
              "meaning": 42, # The meaning field is reserved and should not be used.
              "dateTimeValue": "A String", # A timestamp value.
              "keyValue": { # A unique identifier for an entity. # A key value.
                "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                  { # A (kind, ID/name) pair used to construct a key path.
                      #
                      # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                    "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                    "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                    "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                  },
                ],
                "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                    #
                    # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                  "namespace": "A String", # The namespace.
                  "datasetId": "A String", # The dataset ID.
                },
              },
              "stringValue": "A String", # A UTF-8 encoded string value.
              "indexed": True or False, # If the value should be indexed.
                  #
                  # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
              "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
              "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                { # A message that can hold any of the supported value types and associated metadata.
                  "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
                  "doubleValue": 3.14, # A double value.
                  "integerValue": "A String", # An integer value.
                  "meaning": 42, # The meaning field is reserved and should not be used.
                  "dateTimeValue": "A String", # A timestamp value.
                  "keyValue": { # A unique identifier for an entity. # A key value.
                    "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                      { # A (kind, ID/name) pair used to construct a key path.
                          #
                          # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                        "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                        "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                        "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                      },
                    ],
                    "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                        #
                        # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                      "namespace": "A String", # The namespace.
                      "datasetId": "A String", # The dataset ID.
                    },
                  },
                  "stringValue": "A String", # A UTF-8 encoded string value.
                  "indexed": True or False, # If the value should be indexed.
                      #
                      # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
                  "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
                  "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                    # Object with schema name: Value
                  ],
                  "booleanValue": True or False, # A boolean value.
                  "blobKeyValue": "A String", # A blob key value.
                },
              ],
              "booleanValue": True or False, # A boolean value.
              "blobKeyValue": "A String", # A blob key value.
            },
          },
          "key": { # A unique identifier for an entity. # The entity's key.
              #
              # An entity must have a key, unless otherwise documented (for example, an entity in Value.entityValue may have no key). An entity's kind is its key's path's last element's kind, or null if it has no key.
            "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
              { # A (kind, ID/name) pair used to construct a key path.
                  #
                  # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
              },
            ],
            "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                #
                # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
              "namespace": "A String", # The namespace.
              "datasetId": "A String", # The dataset ID.
            },
          },
        },
      },
    ],
    "header": {
      "kind": "datastore#responseHeader", # Identifies what kind of resource this is. Value: the fixed string "datastore#responseHeader".
    },
    "found": [ # Entities found.
      { # The result of fetching an entity from the datastore.
        "entity": { # An entity. # The resulting entity.
          "properties": { # The entity's properties.
            "a_key": { # An entity property. # The name of the property. A property name matching regex "__.*__" is reserved. A reserved property name is forbidden in certain documented contexts. The name must not contain more than 500 characters. Cannot be "".
              "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
              "doubleValue": 3.14, # A double value.
              "integerValue": "A String", # An integer value.
              "meaning": 42, # The meaning field is reserved and should not be used.
              "dateTimeValue": "A String", # A timestamp value.
              "keyValue": { # A unique identifier for an entity. # A key value.
                "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                  { # A (kind, ID/name) pair used to construct a key path.
                      #
                      # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                    "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                    "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                    "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                  },
                ],
                "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                    #
                    # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                  "namespace": "A String", # The namespace.
                  "datasetId": "A String", # The dataset ID.
                },
              },
              "stringValue": "A String", # A UTF-8 encoded string value.
              "indexed": True or False, # If the value should be indexed.
                  #
                  # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
              "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
              "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                { # A message that can hold any of the supported value types and associated metadata.
                  "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
                  "doubleValue": 3.14, # A double value.
                  "integerValue": "A String", # An integer value.
                  "meaning": 42, # The meaning field is reserved and should not be used.
                  "dateTimeValue": "A String", # A timestamp value.
                  "keyValue": { # A unique identifier for an entity. # A key value.
                    "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                      { # A (kind, ID/name) pair used to construct a key path.
                          #
                          # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                        "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                        "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                        "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                      },
                    ],
                    "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                        #
                        # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                      "namespace": "A String", # The namespace.
                      "datasetId": "A String", # The dataset ID.
                    },
                  },
                  "stringValue": "A String", # A UTF-8 encoded string value.
                  "indexed": True or False, # If the value should be indexed.
                      #
                      # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
                  "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
                  "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                    # Object with schema name: Value
                  ],
                  "booleanValue": True or False, # A boolean value.
                  "blobKeyValue": "A String", # A blob key value.
                },
              ],
              "booleanValue": True or False, # A boolean value.
              "blobKeyValue": "A String", # A blob key value.
            },
          },
          "key": { # A unique identifier for an entity. # The entity's key.
              #
              # An entity must have a key, unless otherwise documented (for example, an entity in Value.entityValue may have no key). An entity's kind is its key's path's last element's kind, or null if it has no key.
            "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
              { # A (kind, ID/name) pair used to construct a key path.
                  #
                  # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
              },
            ],
            "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                #
                # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
              "namespace": "A String", # The namespace.
              "datasetId": "A String", # The dataset ID.
            },
          },
        },
      },
    ],
  }</pre>
</div>

<div class="method">
    <code class="details" id="rollback">rollback(datasetId, body)</code>
  <pre>Roll back a transaction.

Args:
  datasetId: string, Identifies the dataset. (required)
  body: object, The request body. (required)
    The object takes the form of:

{
    "transaction": "A String", # The transaction identifier, returned by a call to beginTransaction.
  }


Returns:
  An object of the form:

    {
    "header": {
      "kind": "datastore#responseHeader", # Identifies what kind of resource this is. Value: the fixed string "datastore#responseHeader".
    },
  }</pre>
</div>

<div class="method">
    <code class="details" id="runQuery">runQuery(datasetId, body)</code>
  <pre>Query for entities.

Args:
  datasetId: string, Identifies the dataset. (required)
  body: object, The request body. (required)
    The object takes the form of:

{
    "query": { # A query. # The query to run. Either this field or field gql_query must be set, but not both.
      "startCursor": "A String", # A starting point for the query results. Optional. Query cursors are returned in query result batches.
      "kinds": [ # The kinds to query (if empty, returns entities from all kinds).
        { # A representation of a kind.
          "name": "A String", # The name of the kind.
        },
      ],
      "projection": [ # The projection to return. If not set the entire entity is returned.
        { # A representation of a property in a projection.
          "aggregationFunction": "A String", # The aggregation function to apply to the property. Optional. Can only be used when grouping by at least one property. Must then be set on all properties in the projection that are not being grouped by. Aggregation functions: first selects the first result as determined by the query's order.
          "property": { # A reference to a property relative to the kind expressions. # The property to project.
            "name": "A String", # The name of the property.
          },
        },
      ],
      "order": [ # The order to apply to the query results (if empty, order is unspecified).
        { # The desired order for a specific property.
          "direction": "A String", # The direction to order by. One of ascending or descending. Optional, defaults to ascending.
          "property": { # A reference to a property relative to the kind expressions. # The property to order by.
            "name": "A String", # The name of the property.
          },
        },
      ],
      "filter": { # A holder for any type of filter. Exactly one field should be specified. # The filter to apply (optional).
        "compositeFilter": { # A filter that merges the multiple other filters using the given operation. # A composite filter.
          "operator": "A String", # The operator for combining multiple filters. Only "and" is currently supported.
          "filters": [ # The list of filters to combine. Must contain at least one filter.
            # Object with schema name: Filter
          ],
        },
        "propertyFilter": { # A filter on a specific property. # A filter on a property.
          "operator": "A String", # The operator to filter by. One of lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, equal, or hasAncestor.
          "property": { # A reference to a property relative to the kind expressions. # The property to filter by.
            "name": "A String", # The name of the property.
          },
          "value": { # A message that can hold any of the supported value types and associated metadata. # The value to compare the property to.
            "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
            "doubleValue": 3.14, # A double value.
            "integerValue": "A String", # An integer value.
            "meaning": 42, # The meaning field is reserved and should not be used.
            "dateTimeValue": "A String", # A timestamp value.
            "keyValue": { # A unique identifier for an entity. # A key value.
              "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                { # A (kind, ID/name) pair used to construct a key path.
                    #
                    # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                  "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                  "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                  "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                },
              ],
              "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                  #
                  # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                "namespace": "A String", # The namespace.
                "datasetId": "A String", # The dataset ID.
              },
            },
            "stringValue": "A String", # A UTF-8 encoded string value.
            "indexed": True or False, # If the value should be indexed.
                #
                # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
            "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
            "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
              # Object with schema name: Value
            ],
            "booleanValue": True or False, # A boolean value.
            "blobKeyValue": "A String", # A blob key value.
          },
        },
      },
      "limit": 42, # The maximum number of results to return. Applies after all other constraints. Optional.
      "offset": 42, # The number of results to skip. Applies before limit, but after all other constraints (optional, defaults to 0).
      "endCursor": "A String", # An ending point for the query results. Optional. Query cursors are returned in query result batches.
      "groupBy": [ # The properties to group by (if empty, no grouping is applied to the result set).
        { # A reference to a property relative to the kind expressions.
          "name": "A String", # The name of the property.
        },
      ],
    },
    "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition. This partition ID is normalized with the standard default context partition ID, but all other partition IDs in RunQueryRequest are normalized with this partition ID as the context partition ID.
        #
        # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
      "namespace": "A String", # The namespace.
      "datasetId": "A String", # The dataset ID.
    },
    "gqlQuery": { # A GQL query. # The GQL query to run. Either this field or field query must be set, but not both.
      "queryString": "A String", # The query string.
      "nameArgs": [ # A named argument must set field GqlQueryArg.name. No two named arguments may have the same name. For each non-reserved named binding site in the query string, there must be a named argument with that name, but not necessarily the inverse.
        { # A binding argument for a GQL query.
          "cursor": "A String",
          "name": "A String", # Must match regex "[A-Za-z_$][A-Za-z_$0-9]*". Must not match regex "__.*__". Must not be "".
          "value": { # A message that can hold any of the supported value types and associated metadata.
            "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
            "doubleValue": 3.14, # A double value.
            "integerValue": "A String", # An integer value.
            "meaning": 42, # The meaning field is reserved and should not be used.
            "dateTimeValue": "A String", # A timestamp value.
            "keyValue": { # A unique identifier for an entity. # A key value.
              "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                { # A (kind, ID/name) pair used to construct a key path.
                    #
                    # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                  "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                  "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                  "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                },
              ],
              "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                  #
                  # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                "namespace": "A String", # The namespace.
                "datasetId": "A String", # The dataset ID.
              },
            },
            "stringValue": "A String", # A UTF-8 encoded string value.
            "indexed": True or False, # If the value should be indexed.
                #
                # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
            "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
            "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
              # Object with schema name: Value
            ],
            "booleanValue": True or False, # A boolean value.
            "blobKeyValue": "A String", # A blob key value.
          },
        },
      ],
      "allowLiteral": True or False, # When false, the query string must not contain a literal.
      "numberArgs": [ # Numbered binding site @1 references the first numbered argument, effectively using 1-based indexing, rather than the usual 0. A numbered argument must NOT set field GqlQueryArg.name. For each binding site numbered i in query_string, there must be an ith numbered argument. The inverse must also be true.
        { # A binding argument for a GQL query.
          "cursor": "A String",
          "name": "A String", # Must match regex "[A-Za-z_$][A-Za-z_$0-9]*". Must not match regex "__.*__". Must not be "".
          "value": { # A message that can hold any of the supported value types and associated metadata.
            "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
            "doubleValue": 3.14, # A double value.
            "integerValue": "A String", # An integer value.
            "meaning": 42, # The meaning field is reserved and should not be used.
            "dateTimeValue": "A String", # A timestamp value.
            "keyValue": { # A unique identifier for an entity. # A key value.
              "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                { # A (kind, ID/name) pair used to construct a key path.
                    #
                    # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                  "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                  "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                  "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                },
              ],
              "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                  #
                  # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                "namespace": "A String", # The namespace.
                "datasetId": "A String", # The dataset ID.
              },
            },
            "stringValue": "A String", # A UTF-8 encoded string value.
            "indexed": True or False, # If the value should be indexed.
                #
                # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
            "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
            "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
              # Object with schema name: Value
            ],
            "booleanValue": True or False, # A boolean value.
            "blobKeyValue": "A String", # A blob key value.
          },
        },
      ],
    },
    "readOptions": { # The options for this query.
      "transaction": "A String", # The transaction to use. Optional.
      "readConsistency": "A String", # The read consistency to use. One of default, strong, or eventual. Cannot be set when transaction is set. Lookup and ancestor queries default to strong, global queries default to eventual and cannot be set to strong. Optional. Default is default.
    },
  }


Returns:
  An object of the form:

    {
    "header": {
      "kind": "datastore#responseHeader", # Identifies what kind of resource this is. Value: the fixed string "datastore#responseHeader".
    },
    "batch": { # A batch of results produced by a query. # A batch of query results (always present).
      "moreResults": "A String", # The state of the query after the current batch. One of notFinished, moreResultsAfterLimit, noMoreResults.
      "entityResults": [ # The results for this batch.
        { # The result of fetching an entity from the datastore.
          "entity": { # An entity. # The resulting entity.
            "properties": { # The entity's properties.
              "a_key": { # An entity property. # The name of the property. A property name matching regex "__.*__" is reserved. A reserved property name is forbidden in certain documented contexts. The name must not contain more than 500 characters. Cannot be "".
                "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
                "doubleValue": 3.14, # A double value.
                "integerValue": "A String", # An integer value.
                "meaning": 42, # The meaning field is reserved and should not be used.
                "dateTimeValue": "A String", # A timestamp value.
                "keyValue": { # A unique identifier for an entity. # A key value.
                  "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                    { # A (kind, ID/name) pair used to construct a key path.
                        #
                        # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                      "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                      "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                      "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                    },
                  ],
                  "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                      #
                      # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                    "namespace": "A String", # The namespace.
                    "datasetId": "A String", # The dataset ID.
                  },
                },
                "stringValue": "A String", # A UTF-8 encoded string value.
                "indexed": True or False, # If the value should be indexed.
                    #
                    # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
                "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
                "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                  { # A message that can hold any of the supported value types and associated metadata.
                    "entityValue": # Object with schema name: Entity # An entity value. May have no key. May have a key with an incomplete key path. May have a reserved/read-only key.
                    "doubleValue": 3.14, # A double value.
                    "integerValue": "A String", # An integer value.
                    "meaning": 42, # The meaning field is reserved and should not be used.
                    "dateTimeValue": "A String", # A timestamp value.
                    "keyValue": { # A unique identifier for an entity. # A key value.
                      "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                        { # A (kind, ID/name) pair used to construct a key path.
                            #
                            # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                          "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                          "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                          "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                        },
                      ],
                      "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                          #
                          # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                        "namespace": "A String", # The namespace.
                        "datasetId": "A String", # The dataset ID.
                      },
                    },
                    "stringValue": "A String", # A UTF-8 encoded string value.
                    "indexed": True or False, # If the value should be indexed.
                        #
                        # The indexed property may be set for a null value. When indexed is true, stringValue is limited to 500 characters and the blob value is limited to 500 bytes. Input values by default have indexed set to true; however, you can explicitly set indexed to true if you want. (An output value never has indexed explicitly set to true.) If a value is itself an entity, it cannot have indexed set to true.
                    "blobValue": "A String", # A blob value. May be a maximum of 1,000,000 bytes.
                    "listValue": [ # A list value. Cannot contain another list value. Cannot also have a meaning and indexing set.
                      # Object with schema name: Value
                    ],
                    "booleanValue": True or False, # A boolean value.
                    "blobKeyValue": "A String", # A blob key value.
                  },
                ],
                "booleanValue": True or False, # A boolean value.
                "blobKeyValue": "A String", # A blob key value.
              },
            },
            "key": { # A unique identifier for an entity. # The entity's key.
                #
                # An entity must have a key, unless otherwise documented (for example, an entity in Value.entityValue may have no key). An entity's kind is its key's path's last element's kind, or null if it has no key.
              "path": [ # The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors. An entity path is always fully complete: ALL of the entity's ancestors are required to be in the path along with the entity identifier itself. The only exception is that in some documented cases, the identifier in the last path element (for the entity) itself may be omitted. A path can never be empty. The path can have at most 100 elements.
                { # A (kind, ID/name) pair used to construct a key path.
                    #
                    # At most one of name or ID may be set. If either is set, the element is complete. If neither is set, the element is incomplete.
                  "kind": "A String", # The kind of the entity. A kind matching regex "__.*__" is reserved/read-only. A kind must not contain more than 500 characters. Cannot be "".
                  "id": "A String", # The ID of the entity. Never equal to zero. Values less than zero are discouraged and will not be supported in the future.
                  "name": "A String", # The name of the entity. A name matching regex "__.*__" is reserved/read-only. A name must not be more than 500 characters. Cannot be "".
                },
              ],
              "partitionId": { # An identifier for a particular subset of entities. # Entities are partitioned into subsets, currently identified by a dataset (usually implicitly specified by the project) and namespace ID. Queries are scoped to a single partition.
                  #
                  # Entities are partitioned into various subsets, each used by different datasets and different namespaces within a dataset and so forth.
                "namespace": "A String", # The namespace.
                "datasetId": "A String", # The dataset ID.
              },
            },
          },
        },
      ],
      "skippedResults": 42, # The number of results skipped because of Query.offset.
      "endCursor": "A String", # A cursor that points to the position after the last result in the batch. May be absent. TODO(arfuller): Once all plans produce cursors update documentation here.
      "entityResultType": "A String", # The result type for every entity in entityResults. full for full entities, projection for entities with only projected properties, keyOnly for entities with only a key.
    },
  }</pre>
</div>

</body></html>